package org.xtext.example.mydsl.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Action;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Attribute;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.BindComponents;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Component;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentActionStatement;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentAlternationConstraint;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentBasedSoftwareDevelopmentPackage;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentBetweenConstraint;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentCausedbyConstraint;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentFollowsConstraint;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentInstance;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentLeadstoConstraint;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.ComponentPrecedesConstraint;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Contract;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.DataType;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Entity;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Interface;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Main;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.PackageDeclaration;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.PackageImport;
import org.xtext.example.mydsl.componentBasedSoftwareDevelopment.Parameter;
import org.xtext.example.mydsl.services.ComponentBasedSoftwareDevelopmentGrammarAccess;

@SuppressWarnings("all")
public class ComponentBasedSoftwareDevelopmentSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private ComponentBasedSoftwareDevelopmentGrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == ComponentBasedSoftwareDevelopmentPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case ComponentBasedSoftwareDevelopmentPackage.ACTION:
				if(context == grammarAccess.getActionRule()) {
					sequence_Action(context, (Action) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.ATTRIBUTE:
				if(context == grammarAccess.getAttributeRule()) {
					sequence_Attribute(context, (Attribute) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.BIND_COMPONENTS:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getBindComponentsRule()) {
					sequence_BindComponents(context, (BindComponents) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getComponentRule()) {
					sequence_Component(context, (Component) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_ACTION_STATEMENT:
				if(context == grammarAccess.getComponentActionStatementRule()) {
					sequence_ComponentActionStatement(context, (ComponentActionStatement) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_ALTERNATION_CONSTRAINT:
				if(context == grammarAccess.getComponentAlternationConstraintRule() ||
				   context == grammarAccess.getComponentStatementRule()) {
					sequence_ComponentAlternationConstraint(context, (ComponentAlternationConstraint) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_BETWEEN_CONSTRAINT:
				if(context == grammarAccess.getComponentBetweenConstraintRule() ||
				   context == grammarAccess.getComponentStatementRule()) {
					sequence_ComponentBetweenConstraint(context, (ComponentBetweenConstraint) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_CAUSEDBY_CONSTRAINT:
				if(context == grammarAccess.getComponentCausedbyConstraintRule() ||
				   context == grammarAccess.getComponentStatementRule()) {
					sequence_ComponentCausedbyConstraint(context, (ComponentCausedbyConstraint) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_FOLLOWS_CONSTRAINT:
				if(context == grammarAccess.getComponentFollowsConstraintRule() ||
				   context == grammarAccess.getComponentStatementRule()) {
					sequence_ComponentFollowsConstraint(context, (ComponentFollowsConstraint) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_INSTANCE:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getComponentInstanceRule()) {
					sequence_ComponentInstance(context, (ComponentInstance) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_LEADSTO_CONSTRAINT:
				if(context == grammarAccess.getComponentLeadstoConstraintRule() ||
				   context == grammarAccess.getComponentStatementRule()) {
					sequence_ComponentLeadstoConstraint(context, (ComponentLeadstoConstraint) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.COMPONENT_PRECEDES_CONSTRAINT:
				if(context == grammarAccess.getComponentPrecedesConstraintRule() ||
				   context == grammarAccess.getComponentStatementRule()) {
					sequence_ComponentPrecedesConstraint(context, (ComponentPrecedesConstraint) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.CONTRACT:
				if(context == grammarAccess.getContractRule()) {
					sequence_Contract(context, (Contract) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.DATA_TYPE:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getDataTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_DataType(context, (DataType) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.ENTITY:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getEntityRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_Entity(context, (Entity) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.INTERFACE:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getInterfaceRule()) {
					sequence_Interface(context, (Interface) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.MAIN:
				if(context == grammarAccess.getMainRule()) {
					sequence_Main(context, (Main) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.PACKAGE_DECLARATION:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getPackageDeclarationRule()) {
					sequence_PackageDeclaration(context, (PackageDeclaration) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.PACKAGE_IMPORT:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getPackageImportRule()) {
					sequence_PackageImport(context, (PackageImport) semanticObject); 
					return; 
				}
				else break;
			case ComponentBasedSoftwareDevelopmentPackage.PARAMETER:
				if(context == grammarAccess.getParameterRule()) {
					sequence_Parameter(context, (Parameter) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (return=[Type|QualifiedName] name=ID (parameters+=Parameter parameters+=Parameter*)?)
	 */
	protected void sequence_Action(EObject context, Action semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (many?='many'? name=ID type=[Type|QualifiedName])
	 */
	protected void sequence_Attribute(EObject context, Attribute semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         leftComponent=[ComponentInstance|QualifiedName] 
	 *         leftContract=[Contract|QualifiedName] 
	 *         rightComponent=[ComponentInstance|QualifiedName] 
	 *         rightContract=[Contract|QualifiedName]
	 *     )
	 */
	protected void sequence_BindComponents(EObject context, BindComponents semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__LEFT_COMPONENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__LEFT_COMPONENT));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__LEFT_CONTRACT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__LEFT_CONTRACT));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__RIGHT_COMPONENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__RIGHT_COMPONENT));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__RIGHT_CONTRACT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.BIND_COMPONENTS__RIGHT_CONTRACT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBindComponentsAccess().getLeftComponentComponentInstanceQualifiedNameParserRuleCall_1_0_1(), semanticObject.getLeftComponent());
		feeder.accept(grammarAccess.getBindComponentsAccess().getLeftContractContractQualifiedNameParserRuleCall_3_0_1(), semanticObject.getLeftContract());
		feeder.accept(grammarAccess.getBindComponentsAccess().getRightComponentComponentInstanceQualifiedNameParserRuleCall_5_0_1(), semanticObject.getRightComponent());
		feeder.accept(grammarAccess.getBindComponentsAccess().getRightContractContractQualifiedNameParserRuleCall_7_0_1(), semanticObject.getRightContract());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (contract=[Contract|ID] action=[Action|QualifiedName])
	 */
	protected void sequence_ComponentActionStatement(EObject context, ComponentActionStatement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ACTION_STATEMENT__CONTRACT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ACTION_STATEMENT__CONTRACT));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ACTION_STATEMENT__ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ACTION_STATEMENT__ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentActionStatementAccess().getContractContractIDTerminalRuleCall_0_0_1(), semanticObject.getContract());
		feeder.accept(grammarAccess.getComponentActionStatementAccess().getActionActionQualifiedNameParserRuleCall_2_0_1(), semanticObject.getAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (action1=ComponentActionStatement action2=ComponentActionStatement)
	 */
	protected void sequence_ComponentAlternationConstraint(EObject context, ComponentAlternationConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ALTERNATION_CONSTRAINT__ACTION1) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ALTERNATION_CONSTRAINT__ACTION1));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ALTERNATION_CONSTRAINT__ACTION2) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_ALTERNATION_CONSTRAINT__ACTION2));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentAlternationConstraintAccess().getAction1ComponentActionStatementParserRuleCall_1_0(), semanticObject.getAction1());
		feeder.accept(grammarAccess.getComponentAlternationConstraintAccess().getAction2ComponentActionStatementParserRuleCall_3_0(), semanticObject.getAction2());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (middleAction=ComponentActionStatement beforeAction=ComponentActionStatement afterAction=ComponentActionStatement)
	 */
	protected void sequence_ComponentBetweenConstraint(EObject context, ComponentBetweenConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_BETWEEN_CONSTRAINT__MIDDLE_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_BETWEEN_CONSTRAINT__MIDDLE_ACTION));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_BETWEEN_CONSTRAINT__BEFORE_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_BETWEEN_CONSTRAINT__BEFORE_ACTION));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_BETWEEN_CONSTRAINT__AFTER_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_BETWEEN_CONSTRAINT__AFTER_ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentBetweenConstraintAccess().getMiddleActionComponentActionStatementParserRuleCall_0_0(), semanticObject.getMiddleAction());
		feeder.accept(grammarAccess.getComponentBetweenConstraintAccess().getBeforeActionComponentActionStatementParserRuleCall_2_0(), semanticObject.getBeforeAction());
		feeder.accept(grammarAccess.getComponentBetweenConstraintAccess().getAfterActionComponentActionStatementParserRuleCall_4_0(), semanticObject.getAfterAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (leftAction=ComponentActionStatement rightAction=ComponentActionStatement)
	 */
	protected void sequence_ComponentCausedbyConstraint(EObject context, ComponentCausedbyConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_CAUSEDBY_CONSTRAINT__LEFT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_CAUSEDBY_CONSTRAINT__LEFT_ACTION));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_CAUSEDBY_CONSTRAINT__RIGHT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_CAUSEDBY_CONSTRAINT__RIGHT_ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentCausedbyConstraintAccess().getLeftActionComponentActionStatementParserRuleCall_0_0(), semanticObject.getLeftAction());
		feeder.accept(grammarAccess.getComponentCausedbyConstraintAccess().getRightActionComponentActionStatementParserRuleCall_2_0(), semanticObject.getRightAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (leftAction=ComponentActionStatement rightAction=ComponentActionStatement)
	 */
	protected void sequence_ComponentFollowsConstraint(EObject context, ComponentFollowsConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_FOLLOWS_CONSTRAINT__LEFT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_FOLLOWS_CONSTRAINT__LEFT_ACTION));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_FOLLOWS_CONSTRAINT__RIGHT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_FOLLOWS_CONSTRAINT__RIGHT_ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentFollowsConstraintAccess().getLeftActionComponentActionStatementParserRuleCall_0_0(), semanticObject.getLeftAction());
		feeder.accept(grammarAccess.getComponentFollowsConstraintAccess().getRightActionComponentActionStatementParserRuleCall_2_0(), semanticObject.getRightAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID component=[Component|QualifiedName])
	 */
	protected void sequence_ComponentInstance(EObject context, ComponentInstance semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_INSTANCE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_INSTANCE__NAME));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_INSTANCE__COMPONENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_INSTANCE__COMPONENT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentInstanceAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getComponentInstanceAccess().getComponentComponentQualifiedNameParserRuleCall_2_0_1(), semanticObject.getComponent());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (leftAction=ComponentActionStatement rightAction=ComponentActionStatement)
	 */
	protected void sequence_ComponentLeadstoConstraint(EObject context, ComponentLeadstoConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_LEADSTO_CONSTRAINT__LEFT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_LEADSTO_CONSTRAINT__LEFT_ACTION));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_LEADSTO_CONSTRAINT__RIGHT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_LEADSTO_CONSTRAINT__RIGHT_ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentLeadstoConstraintAccess().getLeftActionComponentActionStatementParserRuleCall_0_0(), semanticObject.getLeftAction());
		feeder.accept(grammarAccess.getComponentLeadstoConstraintAccess().getRightActionComponentActionStatementParserRuleCall_2_0(), semanticObject.getRightAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (leftAction=ComponentActionStatement rightAction=ComponentActionStatement)
	 */
	protected void sequence_ComponentPrecedesConstraint(EObject context, ComponentPrecedesConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_PRECEDES_CONSTRAINT__LEFT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_PRECEDES_CONSTRAINT__LEFT_ACTION));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_PRECEDES_CONSTRAINT__RIGHT_ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.COMPONENT_PRECEDES_CONSTRAINT__RIGHT_ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentPrecedesConstraintAccess().getLeftActionComponentActionStatementParserRuleCall_0_0(), semanticObject.getLeftAction());
		feeder.accept(grammarAccess.getComponentPrecedesConstraintAccess().getRightActionComponentActionStatementParserRuleCall_2_0(), semanticObject.getRightAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID (provides+=Contract | requires+=Contract)* statements+=ComponentStatement*)
	 */
	protected void sequence_Component(EObject context, Component semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID interface=[Interface|QualifiedName])
	 */
	protected void sequence_Contract(EObject context, Contract semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.CONTRACT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.CONTRACT__NAME));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.CONTRACT__INTERFACE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.CONTRACT__INTERFACE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getContractAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getContractAccess().getInterfaceInterfaceQualifiedNameParserRuleCall_2_0_1(), semanticObject.getInterface());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_DataType(EObject context, DataType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.TYPE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.TYPE__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDataTypeAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID superType=[Entity|QualifiedName]? attributes+=Attribute*)
	 */
	protected void sequence_Entity(EObject context, Entity semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID actions+=Action*)
	 */
	protected void sequence_Interface(EObject context, Interface semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     elements+=AbstractElement*
	 */
	protected void sequence_Main(EObject context, Main semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=QualifiedName elements+=AbstractElement*)
	 */
	protected void sequence_PackageDeclaration(EObject context, PackageDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     importedNamespace=QualifiedNameWithWildCard
	 */
	protected void sequence_PackageImport(EObject context, PackageImport semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.PACKAGE_IMPORT__IMPORTED_NAMESPACE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.PACKAGE_IMPORT__IMPORTED_NAMESPACE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getPackageImportAccess().getImportedNamespaceQualifiedNameWithWildCardParserRuleCall_1_0(), semanticObject.getImportedNamespace());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=[Type|QualifiedName])
	 */
	protected void sequence_Parameter(EObject context, Parameter semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.PARAMETER__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.PARAMETER__NAME));
			if(transientValues.isValueTransient(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.PARAMETER__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ComponentBasedSoftwareDevelopmentPackage.Literals.PARAMETER__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getParameterAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getParameterAccess().getTypeTypeQualifiedNameParserRuleCall_2_0_1(), semanticObject.getType());
		feeder.finish();
	}
}
